This is breaking changes, should we run crate tests?

It would be good to test all permutations of

fn f
let f
macro_rules! m
use m

in all possible orders.
There should be 12 of them (the ones with use m going before macro_rules! m are impossible).

The testing statements let a/b/c/... can then be inserted between all of them.

let a
fn f
let b
let f
let c
macro_rules! m
let d
use m
let e

Then we'll get exhaustive testing.

Upd: i8 -> FnF, i16 -> LetF.

Some more test cases:

{
  m!(); // in a block before the import
}

macro_rules! m { ... }
use m;

As a note, we should add additional test cases like without_decl_f and without_closure_f for better coverage.

note on cases in f0~f23:​​

• For let a: i8 = m!() in f8~f23, the macro expansion's f refers to function f. There are two distinct scenarios:
  1. Using the declared function​ when found at macro definition site:

   fn f20() {
       macro_rules! m {() => ( f() )} // Only resolves to `fn f` at this position
       use m;
       fn f() -> i8 { 42 }
       let f = || -> i16 { 42 };
       let a: i8 = m!();
  }

  This behaves similarly to:

  fn f() {
      let x = 0;
      macro_rules! foo { () => { assert_eq!(x, 0); } }
      let x = 1;
      foo!();
  }

  2. Using the declared function​ when the closure is unavailable:

  fn b12() {
      let a: i8 = m!();
      fn f() -> i8 { 42 }
      let f = || -> i16 { 42 };
      macro_rules! m {() => ( f() )} // Although both exist, `let a` can only use `fn f`
      use m;
  }

• In other cases, it refers to the closure f.